package org.keyyond.ms.business.util;



import org.apache.commons.lang.StringUtils;
import org.apache.log4j.Logger;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;

import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPool;
import redis.clients.jedis.JedisPoolConfig;

/**
 * 
 * @author songjianping
 *
 */

@Component
public class JedisPoolUtils {
//    protected static ReentrantLock lockPool = new ReentrantLock();  
//    protected static ReentrantLock lockJedis = new ReentrantLock();  
  
    protected static Logger logger = Logger.getLogger(JedisPoolUtils.class);  
    
  //Redis服务器IP 
    @Value("${spring.redis.host}")
    private String ADDR_ARRAY;  
  
  //Redis的端口号  
    @Value("${spring.redis.port}")
    private int PORT;  
  
  //访问密码  
    @Value("${spring.redis.password}")
    private String AUTH;  
    
    //可用连接实例的最大数目，默认值为8；  
    //如果赋值为-1，则表示不限制；如果pool已经分配了maxActive个jedis实例，则此时pool的状态为exhausted(耗尽)。  
    @Value("${spring.redis.pool.max-active}")
    private int MAX_ACTIVE;  
  
    //控制一个pool最多有多少个状态为idle(空闲的)的jedis实例，默认值也是8。  
    @Value("${spring.redis.pool.max-idle}")
    private int MAX_IDLE;  
  
    //等待可用连接的最大时间，单位毫秒，默认值为-1，表示永不超时。如果超过等待时间，则直接抛出JedisConnectionException；  
    @Value("${spring.redis.pool.max-wait}")
    private int MAX_WAIT;  
  
    //超时时间  
    @Value("${spring.redis.timeout}")
    private int TIMEOUT;  
  
    //在borrow一个jedis实例时，是否提前进行validate操作；如果为true，则得到的jedis实例均是可用的；  
    private boolean TEST_ON_BORROW = true;  
  
    private JedisPool jedisPool = null;  
  
    /** 
     * 初始化Redis连接池 
     */  
    
    private void initialPool() {  
        try {  
            JedisPoolConfig config = new JedisPoolConfig();  
            config.setMaxTotal(MAX_ACTIVE);  
            config.setMaxIdle(MAX_IDLE);  
            config.setMaxWaitMillis(MAX_WAIT);  
            config.setTestOnBorrow(TEST_ON_BORROW);  
            jedisPool = new JedisPool(config, ADDR_ARRAY, PORT, TIMEOUT, AUTH);  
        } catch (Exception e) {  
            logger.error("create JedisPool error : " + e);  
            e.printStackTrace();
        }  
    }  
  
    /** 
     * 在多线程环境同步初始化 
     */  
    private synchronized void poolInit() {  
        if (jedisPool == null) {    
            initialPool();  
        }  
    }  
  
      
    /** 
     * 同步获取Jedis实例 
     * @return Jedis 
     */  
    public synchronized Jedis getJedis() {    
        if (jedisPool == null) {    
            poolInit();  
        }  
        Jedis jedis = null;  
        try {    
            if (jedisPool != null) {    
                jedis = jedisPool.getResource();   
            }  
        } catch (Exception e) {    
            logger.error("Get jedis error : "+e);  
            e.printStackTrace();
        }
        return jedis;  
    }    
  
//    /** 
//     * 释放jedis资源 
//     * 
//     * @param jedis 
//     */  
//    public void returnResource(Jedis jedis) {  
//        if (jedis != null && jedisPool != null) {
//            jedisPool
//        }  
//    }  
  
    /** 
     * 设置 String 
     * 
     * @param key 
     * @param value 
     */  
    public String setString(String key, String value) { 
    	String result="";
    	Jedis jedis = null;
        try {  
        	jedis = getJedis();
        	value = StringUtils.isEmpty(value) ? "" : value;  
            
            result = jedis.set(key, value);  
            
        } catch (Exception e) {  
            logger.error("Set key error : " + e);  
            e.printStackTrace();
        }finally{
        	if(jedis != null)
        	{
        		jedis.close();
        	}
        }
        return result;
    }  
  
    /** 
     * 设置 过期时间 
     * 
     * @param key 
     * @param seconds 以秒为单位 
     * @param value 
     */  
    public String setString(String key, int seconds, String value) {  
    	String result="";
    	Jedis jedis = null;
        try {  
        	jedis = getJedis();
            value = StringUtils.isEmpty(value) ? "" : value;  
            result = jedis.setex(key, seconds, value); 
        } catch (Exception e) {  
            logger.error("Set keyex error : " + e);  
            e.printStackTrace();
        }finally{
        	if(jedis != null)
        	{
        		jedis.close();
        	}
        }
        return result;
    }  
  
    /** 
     * 获取String值 
     * 
     * @param key 
     * @return value 
     */  
    public String getString(String key) {
    	Jedis jedis = null;
    	String value = null;
        try {  
        	jedis = getJedis();
            value = jedis.get(key);  
        } catch (Exception e) {  
            logger.error("Set keyex error : " + e);  
            e.printStackTrace();
        }finally{
        	if(jedis != null)
        	{
        		jedis.close();
        	}
        }
        
        return value;  
    }
 
    /** 
     * 删除String值 
     * 
     * @param key 
     * @return value 
     */
    public Long delString(String key){
    	
    	Jedis jedis = null;
    	Long del = 0l;
        try {  
        	jedis = getJedis();
        	del = jedis.del(key);
        } catch (Exception e) {  
            logger.error("Set keyex error : " + e);  
            e.printStackTrace();
        }finally{
        	if(jedis != null)
        	{
        		jedis.close();
        	}
        }
        
        return del; 
    }
}
